import java.util.Date;
import java.util.logging.Logger;
import src.de.checker.hochzeit.domain.util.*;
import src.de.checker.hochzeit.domain.user.*;
import src.de.checker.hochzeit.domain.picture.*;
import src.de.checker.hochzeit.konstanten.*
import src.de.checker.hochzeit.util.*;
import com.google.appengine.api.datastore.*
import com.google.appengine.api.memcache.*
import com.google.appengine.api.blobstore.BlobKey
import static com.google.appengine.api.datastore.FetchOptions.Builder.*

/**
 * Verwaltet die Funktionen, die für das verwalten von Fotoalben.
 */
Logger log = Logger.getLogger('PhotoalbumController');

def myuser = session.getAttribute(Konstanten.SESSION_USER);

if(myuser != null)
{
	if(params?.index ==~ /(?i)true/)
	{
		index()
	}
	if(params?.details ==~ /(?i)true/)
	{
		details()
	}
	if(params?.insert ==~ /(?i)true/)
	{
		insert()
	}
	if(params?.cancel ==~ /(?i)true/)
	{
		cancel()
	}
	if(params?.save ==~ /(?i)true/)
	{
		save()
	}
	if(params?.big ==~ /(?i)true/)
	{
		big()
	}
	if(params?.deletepic ==~ /(?i)true/)
	{
		deletepic()
	}
	if(params?.update ==~ /(?i)true/)
	{
		update()
	}
}

private void insert()
{
	def myuser = session.getAttribute(Konstanten.SESSION_USER);
	String feier = myuser.feier
	
	def query = new Query(Konstanten.ALBUM)
	query.addFilter("feier", Query.FilterOperator.EQUAL, feier)
	PreparedQuery preparedQuery = datastore.prepare(query)
 	def entities = preparedQuery.asList( withLimit(30) )
 	request['alben'] = entities
 	
 	def counter = 0;
 	for(album in entities) {
 		def query1 = new Query(Konstanten.PICTURE)
 		query1.addFilter("feier", Query.FilterOperator.EQUAL, feier)
 		query1.addFilter("album", Query.FilterOperator.EQUAL, album.key)
 		PreparedQuery preparedQuery1 = datastore.prepare(query1)
 	 	counter += preparedQuery1.countEntities()
 	}
	request['anzahl'] = counter
	forward '/photoalben/insert.gtpl'
}

private void cancel() {
	def blob = new BlobKey(params.pickey)
	System.out.println("album for delete: "+blob)
	blob.delete()
	insert()
}

private void index()
{
	def myuser = session.getAttribute(Konstanten.SESSION_USER);
	String feier = myuser.feier
	
	//Alle bereits gespeicherten Albem für die Feier suchen
	def query = new Query(Konstanten.ALBUM)
	query.addFilter("feier", Query.FilterOperator.EQUAL, feier)
	PreparedQuery preparedQuery = datastore.prepare(query)
 	def entities = preparedQuery.asList( withLimit(30) )
 	
 	Map anzahl = new HashMap();
 	for(album in entities) {
 		def query1 = new Query(Konstanten.PICTURE)
 		query1.addFilter("feier", Query.FilterOperator.EQUAL, feier)
 		query1.addFilter("album", Query.FilterOperator.EQUAL, album.key)
 		PreparedQuery preparedQuery1 = datastore.prepare(query1)
 	 	int counter = preparedQuery1.countEntities()
 	 	anzahl.put(album.key, counter)
 	}
	
 	request['anzahl'] = anzahl
	request['list'] = entities
 	
	forward '/photoalben/index.gtpl'
}

private void update() {
	def myuser = session.getAttribute(Konstanten.SESSION_USER);
	String feier = myuser.feier
	//System.out.println(params)
	try {
		Key picturekey = KeyFactory.stringToKey(params.pickey)
		def picture = datastore.get(picturekey);
		if(picture.eingestelltVon.equals(myuser.key)) {
			picture.anmerkung = params.beschreibung
			picture.save()
		} else {
			String message = 'Es wurde ein Foto zu editieren, das nicht dem Benutzer gehört. params.pickey: '+params.pickey 
			log.warning(message + " Benutzer der gesucht hat: "+myuser+" Params: "+params)
			createTracer(Konstanten.TRACER_VERBOTEN, message)
		}
	} catch(Exception e) {
		String message = 'Es wurde ein Foto zu bearbeiten, das es nicht gibt. params.key: '+params.key 
		log.warning(e.toString())
		log.warning(message + " Benutzer der gesucht hat: "+myuser+" Params: "+params)
		createTracer(Konstanten.TRACER_NOTFOUND, message)
		index()
	}
	details()
}

private void details() {
	
	// check that a key is present in the cache

	if(!params.max)
		params.max = 6
	if(!params.offset)
		params.offset = 0
	
	int m = (new Integer(params.max)).intValue()
	int o = (new Integer(params.offset)).intValue()
	
	def myuser = session.getAttribute(Konstanten.SESSION_USER);
	String feier = myuser.feier
	Key albumkey = KeyFactory.stringToKey(params.key)
	def album = datastore.get(albumkey);
 	createTracer("FOTOS_GUCKEN",myuser.anzeigename)

 	String memkey = params.key //+"_"+m+"_"+o
 	//System.out.println(memkey)
 	List entities 
 	def all
 	
 	if (memkey in memcache) {
		//System.out.println("found in cache")
		entities = memcache[memkey]
		all = memcache[memkey+"_all"]
 	} else {
		//System.out.println("not found in cache -> query")
		def query = new Query(Konstanten.PICTURE)
		query.addFilter("feier", Query.FilterOperator.EQUAL, feier)
		query.addFilter("album", Query.FilterOperator.EQUAL, albumkey)
		query.addSort("eingestelltAm", Query.SortDirection.ASCENDING);
		PreparedQuery preparedQuery = datastore.prepare(query)
	 	entities = preparedQuery.asList( withLimit(200) )
	 	all = preparedQuery.countEntities();
	 	memcache[memkey] = entities
	 	memcache[memkey+"_all"] = all
	}
	
 	int bis = m+o
 	if(bis > all) {
 		bis = all
 	}
 	System.out.println("listsize: "+all+" get list-entities from "+o+" to "+bis)
    entities = entities.subList(o,bis);
    
 	request['size'] = all
	request['max'] = m
	request['offset'] = o
	
 	request['list'] = entities
 	request['album'] = album
 		
 	forward '/photoalben/details.gtpl'
}

private void big() {
	Key albumkey = KeyFactory.stringToKey(params.album)
	def album = datastore.get(albumkey);
	request['album'] = album
	
	forward '/photoalben/bigpic.gtpl'
}
private void save()
{
	//System.out.println("saving "+params)
	
	def myuser = session.getAttribute(Konstanten.SESSION_USER);
	String feier = myuser.feier
	
	Picture pic = new Picture();
	pic.feier = feier
	pic.eingestelltAm = Datehelper.getNow();
	pic.eingestelltVon = myuser.key
	
	Key albumkey = KeyFactory.stringToKey(params.album)
	def album = datastore.get(albumkey);
	
	pic.album = albumkey
	
	pic.anmerkung = params.beschreibung
	
	pic.blobKey = params.pickey
	
	Entity entity = pic as Entity
	entity.save()
	
	String m = "Ein neues Foto ("+params.pickey+") wurde dem Album "+albumkey+" hinzugefügt"
	System.out.println(m)
	
	String memkey = params.album 
	System.out.println("delete memcache for album"+memkey)
	memcache.delete(memkey);
	         
	createTracer(Konstanten.TRACER_CREATE, m);
	request.message = 'Das Foto wurde erfolgreich dem Album hinzugefügt'
	insert()
	
}
private void deletepic() {
	def myuser = session.getAttribute(Konstanten.SESSION_USER);
	String feier = myuser.feier
	try {
		Key pickey = KeyFactory.stringToKey(params.pickey)
		def picture = datastore.get(pickey);
		if(picture.eingestelltVon.equals(myuser.key) || myuser.rolle == 0) {
			def blob = new BlobKey(picture.blobKey)
	 		blob.delete()
	 		picture.delete()
	 		
	 		String memkey = params.key 
	 		System.out.println("delete memcache for album "+memkey)
	 		memcache.delete(memkey);
			System.out.println("delete memcache for picture "+params.pickey)
	 		memcache.delete(params.pickey);
			
		} else {
			String message = 'Es wurde ein Foto zu löschen, das nicht vom Benutzer eingestellt wurde. params.pickey: '+params.pickey 
			log.warning(message + " Benutzer der gelöscht hat: "+myuser+" Params: "+params)
			createTracer(Konstanten.TRACER_VERBOTEN, message)
		}
		details()
	} catch (Exception e) {
		String message = 'Es wurde ein Foto zu löschen, das es nicht gibt. params.key: '+params.key 
		log.warning(e.toString())
		log.warning(message + " Benutzer der gesucht hat: "+myuser+" Params: "+params)
		createTracer(Konstanten.TRACER_VERBOTEN, message)
		index()
	}
	
}
private void createTracer(String type, String message) {
	try
	{
		def myuser = session.getAttribute(Konstanten.SESSION_USER);

		Tracer t = new Tracer()
	    t.ipadresse = request.getRemoteAddr()
	    t.user = myuser.key
	    t.type = type
	    t.nachricht = message
	    t.datum = Datehelper.getNow()
	    Entity e2 = t as Entity
		e2.save()
	}
	catch(Exception e)
	{
		log.error(e.toString())
	}
}

